Infinite-game Semantics for Logic Programming Languages

This thesis focuses on the study of the semantics of logic programs and the development of infinite games of perfect information between two players, that capture this semantics. We define a game that, given a propositional logic program with negation and a ground atom that belongs to it, may have three possible results (win for any of the players or tie). The game is determined. Based on this, we get a game interpretation of the program that is a model. Moreover, it is equivalent to the well-founded semantics of the program. In order to prove that, we use a new refined game that has infinite possible outcomes. The refined game is also proved to be determined and its game interpretation is a model of the program and equivalent to the infinite valued minimum model semantics of the program. Our study then extends to intensional logic programming a generalization of temporal and modal logic programming. For the monotonic case we develop a game semantics equivalent to the existing semantics. More importantly, we extend it to a three-valued game semantics, the first semantics for the broad class of non-monotonic intensional logic programming languages. 1 Dissertation summary The purpose of this dissertation is to use infinite games in order to provide an alternative, simple and elegant semantics for logic programming languages. We consider two such languages and provide for each one of them a corresponding infinite game that captures its semantics. The first language is that of normal logic programs, i.e. logic programs that allow negative literals in the bodies of clauses. The second language is intensional logic programming, i.e. logic programming extended with intensional operators. The semantics of logic programming has been extensively investigated. Probably the most broadly studied topic in the area is the problem of extending logic programming with negation. The generally accepted computational interpretation of negated atoms is negation-as-failure. Intuitively, a goal ∼A succeeds iff the subcomputation which attempts to establish A terminates and fails. After many years of research, it appears that the most widely acceptable approaches to the semantics of negation-as-failure are the well-founded semantics [35] and ? Dissertation advisor: Panos Rondogiannis, Associate Professor the stable model semantics [14]. The former approach provides a unique “distinguished” model of the program while the latter allows for the possibility of zero, one or many models. This thesis focuses on the well-founded semantics. Game-theoretical semantics has been extensively studied in logic and language [15]. Despite the fact that game semantics is well-established for more mainstream programming languages [2], their application to logic programming has been very restricted. To our knowledge, there exist two other works that deal with the problem of giving a game semantics to logic programming. However, both of them deal with the negation-free case. The first of them, appears in [34] in which M. H. van Emden develops a probabilistic version of logic programming whose proof theory is described using a two-person game. This work, although ground-breaking, does not treat negation. More recently, the game for the negation-free case was also studied in [6], and interesting connections with the classical semantics of logic programming have been established. Less directly connected to our work but very indicative of the connections between game theory and logic programming, is the work of M. De Vos (see for example [5], [4]). More specifically, in [4] certain new logic programming formalisms are introduced in order to model decision-making. It is demonstrated that strategic games and extensive games of perfect information can be represented in these new formalisms in such a way that the equilibria of the games can be retrieved as the stable models or answer-sets of the programs. The starting point of our investigation is the simple game semantics for ordinary negation-less logic programming in [34]. Suppose we have a program P and a goal clause G. We describe how the question, “does G succeed as a query to P” can be reduced to the question, “does Player I have a winning strategy in the game ΓPG”. The game ΓPG is a two person infinite game of perfect information. Player I, who we will also call the Believer, believes that G will succeed and his first move is to play G, thus asserting his belief. Player II, who we will also call the Doubter, thinks G will fail. His first move is to choose one of the variables in G which he thinks will fail on its own, and plays it, thus asserting his doubts. From then on, the play proceeds as follows: the Believer (who thinks the variable just played by the Doubter will in fact succeed) must play a clause in the program whose head is the variable just played; and the Doubter must, on his turn, play one of the variables in the body of this clause. Either player can win by making a move for which his opponent has no legal response. For the Believer, this means playing a clause with an empty body; this happens when the Doubter choses to doubt an atom for which there is a fact in the program. For the Doubter, this means choosing a variable for which there is no rule; in this case the Believer has chosen a rule with a variable in its body for which there is no evidence. Finally, we must give the Doubter an important advantage: he wins if the game never ends. It is not hard to argue informally about the correctness of the game semantics for negation-less programs. If G actually fails, the Doubter’s winning strategy is to repeatedly choose variables which themselves fail. If G succeeds, the Believer’s winning strategy is to repeatedly choose rules that are applicable, ie., for which all the variables in the body succeed. The only subtle point is that the Believer, in choosing applicable rules, must avoid ones like p ← p which do not actually advance the game. Once the standard game is understood in terms of the informal anthropomorphic description given above, it is not hard to see how to extend it to programs with negation. There is one new rule: when one of the players plays a formula of the form ∼p, his opponent must, on the next move, play p. And this move must then be answered by playing a clause whose head is p, and so on. The significance of the new rule is that when a negation is encountered, the players swap roles the Believer becomes the Doubter and vice-versa. For example, suppose that Player II, who doubts q, has just played it. Player I, who believes q, plays the clause q ← r,∼ p. Then Player II, who doubted q, thinks the weak link is ∼ p, and plays it. Player I, who believes q, must believe ∼ p, which means doubting p, and playing it. Thus Player I, who was a believer and believed in q, has now become a doubter, who doubts p. His opponent, who was a doubter, is now a believer (in p) and must find a rule for p to play. The rules for winning or losing require modification. As before, any player who has no legal move loses immediately. Thus either Player I or II can lose if they find themselves, in the doubter’s role, doubting a fact or, in the believer’s role, believing without evidence. Furthermore, if the game play is infinite and after a certain point one of the players remains a doubter, he wins. Finally, if the players swap roles infinitely often, the result is a tie. The game we have just described is determined, i.e. it always has a value, and equivalent to the well-founded semantics of negation. The well-founded semantics is based on a three-valued logic, namely a logic that uses the truth values False, 0 and True. Intuitively, we need to demonstrate that an atom has value True (respectively False) in the well-founded model iff Player I (respectively Player II) has a winning strategy in the corresponding game. Additionally, we have to show that the value 0 corresponds to the case where the best choice for both players is to lead the game to a tie. Establishing the equivalence that we just described is not straightforward. The reason is that, as we are going to see, the wellfounded model is constructed in stages, and the truth values that are introduced in different stages can be thought of as having different “strengths”. On the other hand, the game we have described does not have any notion of different levels of winning or losing. Therefore, in order to establish the equivalence it would be convenient if we had on the one hand a refinement of the well-founded model in which the strengths of truth values are as explicit as possible and on the other hand a refinement of the game that uses different degrees of winning and losing. A characterization of the well-founded model that captures in a logical way this notion of different strengths of truth values has been introduced by P. Rondogiannis and W. W. Wadge in [29, 28]. More specifically, the infinite-valued semantics introduced in [29, 28] is a refinement of the well-founded semantics and it uses instead an infinite number of truth values ordered as follows: F0 < F1 < F2 < · · · < 0 < · · · < T2 < T1 < T0 Inspired by this semantics, we define a refined game which supports different degrees of winning and losing. We show that this game is also determined. We then demonstrate that the interpretation of the program that we get using this new infinite-valued game, is equivalent to the infinite-valued semantics. This will immediately imply that the game interpretation of the initial three-valued game is equivalent to the well-founded semantics. Our study then focuses on Intensional logic programming, an extension of logic programming based on intensional logic. Intensional Logic is an extension of classical logic that was introduced by R. Montague [17] in order to capture the semantics of natural languages. Roughly speaking, intensional logic was proposed as a formal system for understanding and reasoning about context-dependent properties of natural language expressions. In its initial form, intensional logic was a higher-order one, equipped with modal and temporal operators [13]. However, the term “intensional logics” can also be used more loosely in order to describe a large class of logics for reasoning about context-dependent phenomena [20]. Temporal logics and modal logics are special cases of intensional logic. Based on this broad interpretation of the term, M. Orgun and W. W. Wadge introduced in [24] the notion of intensional logic programming, which includes as special cases many non-classical extensions of logic programming (such as temporal logic programming, modal logic programming, and so on). As pointed out in [24], numerous logic programming languages that have been proposed in the literature can be characterized as “intensional” (such as Chronolog [24], Tempura [19], Molog [7], Cactus [27], MProlog [22] and so on). It was therefore natural to wonder whether there exists a common semantic framework for handling all these systems in a uniform way. As it was demonstrated in [24], if the intensional operators of the source intensional logic programming language obey some simple semantic properties, then the programs of the language are guaranteed to possess the minimum model property. However, all the intensional operators allowed in [24] are assumed to satisfy the monotonicity property and this excludes many interesting applications that involve non-monotonicity, which is a crucial concept involved in knowledge representation and reasoning. Our purpose is to extend the framework of [24] to allow arbitrary (nonmonotonic) intensional operators in the bodies of program clauses and to define a general semantic framework for non-monotonic intensional logic programming. Our approach is again based on game semantics. We begin by constructing a simple two-person game for the class of intensional logic programs considered in [24] (in which the intensional operators are monotonic, universal and conjunctive). We demonstrate that the outcome of the game coincides with the minimum model semantics obtained in [24]. In this way we provide an equivalent formulation to the approach of Orgun and Wadge for facilitating the further study of intensional logic programs. We then extend the proposed game to handle intensional logic programs that even use non-monotonic operators in the bodies of clauses and show that the games are determined. In this way we obtain the first general semantic framework for non-monotonic intensional logic programming. It should be noted that intensional logic programming, due to its variety of operators, allows a much broader framework for non-monotonicity than classical logic programming where the main source of non-monotonicity is the operator of negation-as-failure.